/*
 * STA and AP APIs for XRadio drivers
 *
 * Copyright (c) 2013
 * Xradio Technology Co., Ltd. <www.xradiotech.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include "xradio.h"
#include "sta.h"
#include "ap.h"
#include "bh.h"
#include "net/mac80211.h"

#define XRADIO_LINK_ID_GC_TIMEOUT        ((unsigned long)(10 * HZ))
#define XRADIO_ENABLE_ARP_FILTER_OFFLOAD  3

#ifndef ERP_INFO_BYTE_OFFSET
#define ERP_INFO_BYTE_OFFSET 2
#endif

#ifdef IPV6_FILTERING
#define XRADIO_ENABLE_NDP_FILTER_OFFLOAD	3
#endif /*IPV6_FILTERING */

static int xradio_upload_beacon(struct xradio_vif *priv);
#ifdef PROBE_RESP_EXTRA_IE
static int xradio_upload_proberesp(struct xradio_vif *priv);
#endif
static int xradio_upload_pspoll(struct xradio_vif *priv);
static int xradio_upload_null(struct xradio_vif *priv);
static int xradio_upload_qosnull(struct xradio_vif *priv);
static int xradio_start_ap(struct xradio_vif *priv);
static int xradio_update_beaconing(struct xradio_vif *priv);
/*
static int xradio_enable_beaconing(struct xradio_vif *priv,
				   bool enable);
*/
static void __xradio_sta_notify(struct xradio_vif *priv,
				enum sta_notify_cmd notify_cmd, int link_id);

/* ******************************************************************** */
/* AP API */
int xradio_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
		   struct ieee80211_sta *sta)
{
	struct xradio_sta_priv *sta_priv =
	    (struct xradio_sta_priv *)&sta->drv_priv;
	struct xradio_vif *priv = xrwl_get_vif_from_ieee80211(vif);
	struct xradio_link_entry *entry;
	struct sk_buff *skb;
#ifdef AP_AGGREGATE_FW_FIX
	struct xradio_common *hw_priv = hw->priv;
#endif

	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);
	if (!atomic_read(&priv->enabled)) {
		ap_printk(XRADIO_DBG_NIY, "%s vif(type=%d) is not enable!\n",
				__func__, vif->type);
		return 0;
	}

#ifdef P2P_MULTIVIF
	SYS_WARN(priv->if_id == XRWL_GENERIC_IF_ID);
#endif

	if (priv->mode != NL80211_IFTYPE_AP) {
		return 0;
	}

	sta_priv->priv = priv;
	sta_priv->link_id = xradio_find_link_id(priv, sta->addr);
	if (SYS_WARN(!sta_priv->link_id)) {
		/* Impossible error */
		ap_printk(XRADIO_DBG_ERROR, "No more link IDs available.\n");
		return -ENOENT;
	}

	entry = &priv->link_id_db[sta_priv->link_id - 1];
	spin_lock_bh(&priv->ps_state_lock);
	if ((sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK) ==
	    IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK) {
		priv->sta_asleep_mask |= BIT(sta_priv->link_id);
	}
	entry->status = XRADIO_LINK_HARD;
	while ((skb = skb_dequeue(&entry->rx_queue)))
		mac80211_rx_irqsafe(priv->hw, skb);
	spin_unlock_bh(&priv->ps_state_lock);

#ifdef AP_AGGREGATE_FW_FIX
	hw_priv->connected_sta_cnt++;
	if (hw_priv->connected_sta_cnt > 1 &&
		WSM_VERSION_BF(hw_priv->wsm_caps, 8, 39)) {
		wsm_lock_tx(hw_priv);
		SYS_WARN(wsm_set_block_ack_policy(hw_priv,
						  XRADIO_TX_BLOCK_ACK_DISABLED_FOR_ALL_TID,
						  XRADIO_RX_BLOCK_ACK_DISABLED_FOR_ALL_TID,
						  priv->if_id));
		wsm_unlock_tx(hw_priv);
		ap_printk(XRADIO_DBG_WARN, "%s: disable BA.\n", __func__);
	}
#endif

	return 0;
}

int xradio_sta_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
		      struct ieee80211_sta *sta)
{
	struct xradio_common *hw_priv = hw->priv;
	struct xradio_sta_priv *sta_priv =
	    (struct xradio_sta_priv *)&sta->drv_priv;
	struct xradio_vif *priv = xrwl_get_vif_from_ieee80211(vif);
	struct xradio_link_entry *entry;
	int suspend_lock_state;

	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);
	suspend_lock_state = atomic_cmpxchg(&hw_priv->suspend_lock_state,
								XRADIO_SUSPEND_LOCK_IDEL, XRADIO_SUSPEND_LOCK_OTHERS);
	if (suspend_lock_state == XRADIO_SUSPEND_LOCK_SUSPEND) {
		sta_printk(XRADIO_DBG_WARN,
				"%s:refuse because of suspend\n", __func__);
		return -EBUSY;
	}
	down(&hw_priv->conf_lock);
	atomic_set(&hw_priv->suspend_lock_state, XRADIO_SUSPEND_LOCK_IDEL);

	if (!atomic_read(&priv->enabled)) {
		up(&hw_priv->conf_lock);
		ap_printk(XRADIO_DBG_NIY, "%s vif(type=%d) is not enable!\n",
				__func__, vif->type);
		return 0;
	}

#ifdef P2P_MULTIVIF
	SYS_WARN(priv->if_id == XRWL_GENERIC_IF_ID);
#endif

	if (priv->mode != NL80211_IFTYPE_AP || !sta_priv->link_id) {
		up(&hw_priv->conf_lock);
		ap_printk(XRADIO_DBG_NIY, "no station to remove\n");
		return 0;
	}

	entry = &priv->link_id_db[sta_priv->link_id - 1];
	spin_lock_bh(&priv->ps_state_lock);
	entry->status = XRADIO_LINK_RESERVE;
	entry->timestamp = jiffies;
	wsm_lock_tx_async(hw_priv);
	if (queue_work(hw_priv->workqueue, &priv->link_id_work) <= 0)
		wsm_unlock_tx(hw_priv);
	spin_unlock_bh(&priv->ps_state_lock);
	up(&hw_priv->conf_lock);
	flush_workqueue(hw_priv->workqueue);
	flush_workqueue(hw_priv->spare_workqueue);

#ifdef AP_AGGREGATE_FW_FIX
	hw_priv->connected_sta_cnt--;
	if (hw_priv->connected_sta_cnt <= 1 &&
		WSM_VERSION_BF(hw_priv->wsm_caps, 8, 39)) {
		if ((priv->if_id != 1) ||
		    ((priv->if_id == 1) && hw_priv->is_go_thru_go_neg)) {
			wsm_lock_tx(hw_priv);
			SYS_WARN(wsm_set_block_ack_policy(hw_priv,
							  XRADIO_TX_BLOCK_ACK_ENABLED_FOR_ALL_TID,
							  XRADIO_RX_BLOCK_ACK_ENABLED_FOR_ALL_TID,
							  priv->if_id));
			wsm_unlock_tx(hw_priv);
		}
	}
#endif

	return 0;
}

static void __xradio_sta_notify(struct xradio_vif *priv,
				enum sta_notify_cmd notify_cmd, int link_id)
{
	struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
	u32 bit, prev;

	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	/* Zero link id means "for all link IDs" */
	if (link_id)
		bit = BIT(link_id);
	else if (WARN_ON_ONCE(notify_cmd != STA_NOTIFY_AWAKE))
		bit = 0;
	else
		bit = priv->link_id_map;
	prev = priv->sta_asleep_mask & bit;

	switch (notify_cmd) {
	case STA_NOTIFY_SLEEP:
		if (!prev) {
			if (priv->buffered_multicasts && !priv->sta_asleep_mask)
				queue_work(hw_priv->workqueue,
					   &priv->multicast_start_work);
			priv->sta_asleep_mask |= bit;
			ap_printk(XRADIO_DBG_NIY, "%s STAs sleep: 0x%08X\n",
				__func__, bit);
		}
		break;
	case STA_NOTIFY_AWAKE:
		if (prev) {
			priv->sta_asleep_mask &= ~bit;
			priv->pspoll_mask &= ~bit;
			if (priv->tx_multicast && link_id &&
			    !priv->sta_asleep_mask)
				queue_work(hw_priv->workqueue,
					   &priv->multicast_stop_work);
			xradio_proc_wakeup(hw_priv);
			ap_printk(XRADIO_DBG_NIY, "%s STAs awake: 0x%08X\n",
				__func__, bit);
		}
		break;
	}
}

void xradio_sta_notify(struct ieee80211_hw *dev,
		       struct ieee80211_vif *vif,
		       enum sta_notify_cmd notify_cmd,
		       struct ieee80211_sta *sta)
{
	struct xradio_vif *priv = xrwl_get_vif_from_ieee80211(vif);
	struct xradio_sta_priv *sta_priv =
	    (struct xradio_sta_priv *)&sta->drv_priv;

	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);
	if (!atomic_read(&priv->enabled)) {
		ap_printk(XRADIO_DBG_NIY, "%s vif(type=%d) is not enable!\n",
				__func__, vif->type);
		return ;
	}

#ifdef P2P_MULTIVIF
	SYS_WARN(priv->if_id == XRWL_GENERIC_IF_ID);
#endif
	spin_lock_bh(&priv->ps_state_lock);
	__xradio_sta_notify(priv, notify_cmd, sta_priv->link_id);
	spin_unlock_bh(&priv->ps_state_lock);
}

static void xradio_ps_notify(struct xradio_vif *priv, int link_id, bool ps)
{
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	if (link_id > MAX_STA_IN_AP_MODE) {
		ap_printk(XRADIO_DBG_WARN, "link_id is invalid=%d\n", link_id);
		return;
	}

	ap_printk(XRADIO_DBG_NIY, "%s for LinkId: %d. STAs asleep: %.8X\n",
		  ps ? "Stop" : "Start", link_id, priv->sta_asleep_mask);

	/* TODO:COMBO: __xradio_sta_notify changed. */
	__xradio_sta_notify(priv, ps ? STA_NOTIFY_SLEEP : STA_NOTIFY_AWAKE,
			    link_id);
}

static int xradio_set_tim_impl(struct xradio_vif *priv, bool aid0_bit_set)
{
	struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
	struct sk_buff *skb;
	struct wsm_update_ie update_ie = {
		.what = WSM_UPDATE_IE_BEACON,
		.count = 1,
	};
	u16 tim_offset, tim_length;
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);
	ap_printk(XRADIO_DBG_MSG, "%s mcast: %s.\n", __func__,
		      aid0_bit_set ? "ena" : "dis");

	skb = mac80211_beacon_get_tim(priv->hw, priv->vif, &tim_offset,
				&tim_length);
	if (!skb) {
		__xradio_flush(hw_priv, true, priv->if_id);
		return -ENOENT;
	}

	if (tim_offset && tim_length >= 6) {
		/* Ignore DTIM count from mac80211:
		 * firmware handles DTIM internally. */
		skb->data[tim_offset + 2] = 0;

		/* Set/reset aid0 bit */
		if (aid0_bit_set)
			skb->data[tim_offset + 4] |= 1;
		else
			skb->data[tim_offset + 4] &= ~1;
	}

	update_ie.ies = &skb->data[tim_offset];
	update_ie.length = tim_length;
	/*filter same tim info*/
	if (memcmp(priv->last_tim, update_ie.ies, tim_length)) {
		SYS_WARN(wsm_update_ie(hw_priv, &update_ie, priv->if_id));
		memcpy(priv->last_tim, update_ie.ies, tim_length);
		ap_printk(XRADIO_DBG_MSG, "%02x %02x %02x %02x %02x %02x\n",
			  update_ie.ies[0], update_ie.ies[1], update_ie.ies[2],
			  update_ie.ies[3], update_ie.ies[4], update_ie.ies[5]);
	}

	dev_kfree_skb(skb);

	return 0;
}

void xradio_set_tim_work(struct work_struct *work)
{
	struct xradio_vif *priv =
	    container_of(work, struct xradio_vif, set_tim_work);
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	xradio_set_tim_impl(priv, priv->aid0_bit_set);
}

int xradio_set_tim(struct ieee80211_hw *dev, struct ieee80211_sta *sta,
		   bool set)
{
	struct xradio_sta_priv *sta_priv =
	    (struct xradio_sta_priv *)&sta->drv_priv;
	struct xradio_vif *priv = sta_priv->priv;

	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);
	if (!atomic_read(&priv->enabled)) {
		ap_printk(XRADIO_DBG_WARN, "%s vif is not enable!\n", __func__);
		return 0;
	}

#ifdef P2P_MULTIVIF
	SYS_WARN(priv->if_id == XRWL_GENERIC_IF_ID);
#endif
	SYS_WARN(priv->mode != NL80211_IFTYPE_AP);
	queue_work(priv->hw_priv->workqueue, &priv->set_tim_work);
	return 0;
}

void xradio_set_cts_work(struct work_struct *work)
{
	struct xradio_vif *priv =
	    container_of(work, struct xradio_vif, set_cts_work.work);
	struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
	u8 erp_ie[3] = { WLAN_EID_ERP_INFO, 0x1, 0 };
	struct wsm_update_ie update_ie = {
		.what = WSM_UPDATE_IE_BEACON,
		.count = 1,
		.ies = erp_ie,
		.length = 3,
	};
	u32 erp_info;
	__le32 use_cts_prot;
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	down(&hw_priv->conf_lock);
	erp_info = priv->erp_info;
	up(&hw_priv->conf_lock);
	use_cts_prot = (erp_info & WLAN_ERP_USE_PROTECTION) ?
			__cpu_to_le32(1) : 0;

	erp_ie[ERP_INFO_BYTE_OFFSET] = erp_info;

	ap_printk(XRADIO_DBG_MSG, "ERP information 0x%x\n", erp_info);

	/* TODO:COMBO: If 2 interfaces are on the same channel they share
	   the same ERP values */
	SYS_WARN(wsm_write_mib(hw_priv, WSM_MIB_ID_NON_ERP_PROTECTION,
			       &use_cts_prot, sizeof(use_cts_prot),
			       priv->if_id));
	/* If STA Mode update_ie is not required */
	if (priv->mode != NL80211_IFTYPE_STATION &&
		priv->mode != NL80211_IFTYPE_P2P_DEVICE) {
		SYS_WARN(wsm_update_ie(hw_priv, &update_ie, priv->if_id));
	}

	return;
}

static int xradio_set_btcoexinfo(struct xradio_vif *priv)
{
	struct wsm_override_internal_txrate arg;
	int ret = 0;

#ifdef SUPPORT_HT40

	u8 rateIndex = 0x0;

#endif

	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	if (priv->mode == NL80211_IFTYPE_STATION ||
		priv->mode == NL80211_IFTYPE_P2P_DEVICE) {
		/* Plumb PSPOLL and NULL template */
		SYS_WARN(xradio_upload_pspoll(priv));
		SYS_WARN(xradio_upload_null(priv));
	} else {
		return 0;
	}

	memset(&arg, 0, sizeof(struct wsm_override_internal_txrate));

	if (!priv->vif->p2p) {
		/* STATION mode */
		if (priv->bss_params.operationalRateSet & ~0xF) {
			ap_printk(XRADIO_DBG_NIY, "STA has ERP rates\n");
			/* G or BG mode */

#ifdef SUPPORT_HT40

			rateIndex =
			(__ffs(priv->bss_params.operationalRateSet & ~0xF));

			arg.internalTxRateEntry =
				xradio_get_rate_entry(priv->hw_priv, 0, 0,
								rateIndex);

#else

			arg.internalTxRate =
			    (__ffs(priv->bss_params.operationalRateSet & ~0xF));

#endif
		} else {
			ap_printk(XRADIO_DBG_NIY, "STA has non ERP rates\n");
			/* B only mode */

#ifdef SUPPORT_HT40

			rateIndex =
			(__ffs(priv->association_mode.basicRateSet));

			arg.internalTxRateEntry =
				xradio_get_rate_entry(priv->hw_priv, 0, 0,
								rateIndex);

#else

			arg.internalTxRate =
			    (__ffs(priv->association_mode.basicRateSet));

#endif
		}

#ifdef SUPPORT_HT40

		rateIndex = (__ffs(priv->association_mode.basicRateSet));
		arg.nonErpInterTxRateEntry =
			xradio_get_rate_entry(priv->hw_priv, 0, 0, rateIndex);

#else
		arg.nonErpInternalTxRate =
		    (__ffs(priv->association_mode.basicRateSet));

#endif
	} else {
		/* P2P mode */

#ifdef SUPPORT_HT40

		rateIndex = (__ffs(priv->bss_params.operationalRateSet & ~0xF));

		arg.internalTxRateEntry =
			xradio_get_rate_entry(priv->hw_priv, 0, 0, rateIndex);

		arg.nonErpInterTxRateEntry = arg.internalTxRateEntry;

#else

		arg.internalTxRate =
		    (__ffs(priv->bss_params.operationalRateSet & ~0xF));
		arg.nonErpInternalTxRate =
		    (__ffs(priv->bss_params.operationalRateSet & ~0xF));

#endif

	}

#ifdef SUPPORT_HT40

	ap_printk(XRADIO_DBG_NIY, "[STA] BTCOEX_INFO" \
		"MODE %d, internalTxRateEntry : " \
		"0x%04x, nonErpInterTxRateEntry: 0x%04x\n",
		priv->mode, arg.internalTxRateEntry,
		arg.nonErpInterTxRateEntry);

#else

	ap_printk(XRADIO_DBG_NIY, "BTCOEX_INFO" "MODE %d, internalTxRate : %x, " \
		  "nonErpInternalTxRate: %x\n", priv->mode, arg.internalTxRate,
		  arg.nonErpInternalTxRate);

#endif

	ret = SYS_WARN(wsm_write_mib(xrwl_vifpriv_to_hwpriv(priv),
				     WSM_MIB_ID_OVERRIDE_INTERNAL_TX_RATE,
				     &arg, sizeof(arg), priv->if_id));

	return ret;
}

void xradio_bss_info_changed(struct ieee80211_hw *dev,
			     struct ieee80211_vif *vif,
			     struct ieee80211_bss_conf *info, u32 changed)
{
	struct xradio_common *hw_priv = dev->priv;
	struct xradio_vif *priv = xrwl_get_vif_from_ieee80211(vif);

	enum nl80211_channel_type chan_type = cfg80211_get_chandef_type(&info->chandef);

	int suspend_lock_state;

	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	if (hw_priv->bh_error) {
		ap_printk(XRADIO_DBG_ERROR, "%s bh_error occurs, changed=0x%0x\n",
			__func__, changed);
		return;
	}

#ifdef P2P_MULTIVIF
	if (priv->if_id == XRWL_GENERIC_IF_ID)
		return;
#endif

	suspend_lock_state = atomic_cmpxchg(&hw_priv->suspend_lock_state,
								XRADIO_SUSPEND_LOCK_IDEL, XRADIO_SUSPEND_LOCK_OTHERS);
	if (suspend_lock_state == XRADIO_SUSPEND_LOCK_SUSPEND) {
		ap_printk(XRADIO_DBG_WARN,
			   "%s:refuse because of suspend\n", __func__);
		return;
	}

	down(&hw_priv->conf_lock);
	atomic_set(&hw_priv->suspend_lock_state, XRADIO_SUSPEND_LOCK_IDEL);

	/*We do somethings first which is not of priv.*/
	if (changed & IEEE80211_CONF_CHANGE_RETRY_LIMITS) {
		spin_lock_bh(&hw_priv->tx_policy_cache.lock);
		/*TODO:COMBO: for now it's still handled per hw and kept
		 * in xradio_common */
#ifdef ENHANCE_ANTI_INTERFERE
		hw_priv->long_frame_max_tx_count  = 15;
		hw_priv->short_frame_max_tx_count = 15;
#else
		hw_priv->long_frame_max_tx_count  = info->retry_long;
		hw_priv->short_frame_max_tx_count =
				(info->retry_short < 0x0F ? info->retry_short : 0x0F);
#endif

		hw_priv->hw->max_rate_tries = hw_priv->short_frame_max_tx_count;
		spin_unlock_bh(&hw_priv->tx_policy_cache.lock);
		ap_printk(XRADIO_DBG_NIY, "Retry limits: long=%d(), short=%d().\n",
			  hw_priv->short_frame_max_tx_count,
			  hw_priv->long_frame_max_tx_count);
		/* TBD: I think we don't need tx_policy_force_upload().
		 * Outdated policies will leave cache in a normal way. */
		/* SYS_WARN(tx_policy_force_upload(priv)); */
	}

	/*We check priv before operation of priv.*/
	if (!atomic_read(&priv->enabled)) {
		if (changed & ~IEEE80211_CONF_CHANGE_RETRY_LIMITS)
			ap_printk(XRADIO_DBG_WARN, "%s vif(type=%d) is not enable!" \
					"changed=0x%x\n", __func__, vif->type, changed);
		up(&hw_priv->conf_lock);
		return ;
	}

	if (changed & BSS_CHANGED_BSSID) {
#ifdef CONFIG_XRADIO_TESTMODE
		spin_lock_bh(&hw_priv->tsm_lock);
		if (hw_priv->tsm_info.sta_associated) {
			unsigned now = jiffies;
			hw_priv->tsm_info.sta_roamed = 1;
			if ((now - hw_priv->tsm_info.txconf_timestamp_vo) >
			    (now - hw_priv->tsm_info.rx_timestamp_vo))
				hw_priv->tsm_info.use_rx_roaming = 1;
		} else {
			hw_priv->tsm_info.sta_associated = 1;
		}
		spin_unlock_bh(&hw_priv->tsm_lock);
#endif /*CONFIG_XRADIO_TESTMODE */
		memcpy(priv->bssid, info->bssid, ETH_ALEN);
		xradio_setup_mac_pvif(priv);
	}

	/* TODO: BSS_CHANGED_IBSS */
	if (changed & BSS_CHANGED_ARP_FILTER) {
		struct wsm_arp_ipv4_filter filter = { 0 };
		int i;
		ap_printk(XRADIO_DBG_MSG,
			  "[STA] BSS_CHANGED_ARP_FILTER enabled: , cnt: %d\n",
			  info->arp_addr_cnt);

		//if (info->arp_filter_enabled) {
		if (info->arp_addr_cnt) {
			if (vif->type == NL80211_IFTYPE_STATION ||
				vif->type == NL80211_IFTYPE_P2P_DEVICE)
				filter.enable =
				    (u32) XRADIO_ENABLE_ARP_FILTER_OFFLOAD;
			else if (priv->join_status == XRADIO_JOIN_STATUS_AP)
				filter.enable = (u32) (1 << 1);
			else
				filter.enable = 0;
		}

		/* Currently only one IP address is supported by firmware.
		 * In case of more IPs arp filtering will be disabled. */
		if (info->arp_addr_cnt > 0 &&
		    info->arp_addr_cnt <= WSM_MAX_ARP_IP_ADDRTABLE_ENTRIES) {
			for (i = 0; i < info->arp_addr_cnt; i++) {
				filter.ipv4Address[i] = info->arp_addr_list[i];
				ap_printk(XRADIO_DBG_NIY,
					  "[STA]addr[%d]: 0x%X\n", i,
					  filter.ipv4Address[i]);
			}
		} else
			filter.enable = 0;

		if (filter.enable)
			xradio_set_arpreply(dev, vif);

		priv->filter4.enable = filter.enable;
		ap_printk(XRADIO_DBG_NIY, "[STA]arp ip filter enable: %d\n",
			  __le32_to_cpu(filter.enable));

		if (wsm_set_arp_ipv4_filter(hw_priv, &filter, priv->if_id))
			SYS_WARN(1);

		if (filter.enable &&
		    (priv->join_status == XRADIO_JOIN_STATUS_STA)) {
			/* Firmware requires that value for this 1-byte field must
			 * be specified in units of 500us. Values above the 128ms
			 * threshold are not supported. */
			ap_printk(XRADIO_DBG_NIY,
				  "[STA]fastPsmIdle=%d, apPsmChange=%d\n",
				  priv->powersave_mode.fastPsmIdlePeriod,
				  priv->powersave_mode.apPsmChangePeriod);

			if (priv->setbssparams_done) {
				int ret = 0;
				struct wsm_set_pm pm = priv->powersave_mode;
				if (priv->user_power_set_true)
					priv->powersave_mode.pmMode = priv->user_pm_mode;
				else if ((priv->power_set_true &&
					 ((priv->powersave_mode.pmMode == WSM_PSM_ACTIVE) ||
					 (priv->powersave_mode.pmMode == WSM_PSM_PS)))    ||
					 !priv->power_set_true)
					priv->powersave_mode.pmMode = WSM_PSM_FAST_PS;

				priv->powersave_mode.pmMode |= WSM_PSM_IP_ALLOCATED;
				ret = xradio_set_pm(priv, &priv->powersave_mode);
				priv->powersave_mode.pmMode &= ~WSM_PSM_IP_ALLOCATED;
				if (ret)
					priv->powersave_mode = pm;
			} else {
				ap_printk(XRADIO_DBG_WARN, "arp_addr_cnt not clear at disconnecting,filter abnormal enable!!!\n");
			}
			priv->power_set_true = 0;
			priv->user_power_set_true = 0;
		}
	}

#if IPV6_FILTERING
	if (changed & BSS_CHANGED_NDP_FILTER) {
		int i;
		struct wsm_ndp_ipv6_filter filter = { 0 };
		u16 *ipv6addr = NULL;

		ap_printk(XRADIO_DBG_MSG,
			  "[STA] BSS_CHANGED_NDP_FILTER enabled: %d, cnt: %d\n",
			  info->ndp_filter_enabled, info->ndp_addr_cnt);

		if (info->ndp_filter_enabled) {
			if (vif->type == NL80211_IFTYPE_STATION ||
				vif->type == NL80211_IFTYPE_P2P_DEVICE)
				filter.enable =
				    (u32) XRADIO_ENABLE_NDP_FILTER_OFFLOAD;
			else if (vif->type == NL80211_IFTYPE_AP)
				filter.enable = (u32) (1 << 1);
			else
				filter.enable = 0;
		}

		/* Currently only one IP address is supported by firmware.
		 * In case of more IPs ndp filtering will be disabled. */
		if (info->ndp_addr_cnt > 0 &&
		    info->ndp_addr_cnt <= WSM_MAX_NDP_IP_ADDRTABLE_ENTRIES) {
			for (i = 0; i < info->ndp_addr_cnt; i++) {
				filter.ipv6Address[i] = info->ndp_addr_list[i];
				priv->filter6.ipv6Address[i] = filter.ipv6Address[i];
				ipv6addr = (u16 *)(&filter.ipv6Address[i]);
				ap_printk(XRADIO_DBG_MSG,
					  "[STA] ipv6 addr[%d]: %x:%x:%x:%x:%x:%x:%x:%x\n",
					  i, cpu_to_be16(*(ipv6addr + 0)),
					  cpu_to_be16(*(ipv6addr + 1)),
					  cpu_to_be16(*(ipv6addr + 2)),
					  cpu_to_be16(*(ipv6addr + 3)),
					  cpu_to_be16(*(ipv6addr + 4)),
					  cpu_to_be16(*(ipv6addr + 5)),
					  cpu_to_be16(*(ipv6addr + 6)),
					  cpu_to_be16(*(ipv6addr + 7)));
			}
		} else {
			filter.enable = 0;
			for (i = 0; i < info->ndp_addr_cnt; i++) {
				ipv6addr = (u16 *) (&info->ndp_addr_list[i]);
				ap_printk(XRADIO_DBG_MSG,
					  "[STA] ipv6 addr[%d]: %x:%x:%x:%x:%x:%x:%x:%x\n",
					  i, cpu_to_be16(*(ipv6addr + 0)),
					  cpu_to_be16(*(ipv6addr + 1)),
					  cpu_to_be16(*(ipv6addr + 2)),
					  cpu_to_be16(*(ipv6addr + 3)),
					  cpu_to_be16(*(ipv6addr + 4)),
					  cpu_to_be16(*(ipv6addr + 5)),
					  cpu_to_be16(*(ipv6addr + 6)),
					  cpu_to_be16(*(ipv6addr + 7)));
			}
		}

		ap_printk(XRADIO_DBG_NIY, "[STA] ndp ip filter enable: %d\n",
			   __le32_to_cpu(filter.enable));

		if (filter.enable)
			xradio_set_na(dev, vif);

		priv->filter6.enable = filter.enable;

		if (wsm_set_ndp_ipv6_filter(hw_priv, &filter, priv->if_id))
			SYS_WARN(1);
#if 0				/*Commented out to disable Power Save in IPv6 */
		if (filter.enable
		    && (priv->join_status == XRADIO_JOIN_STATUS_STA)
		    && (priv->vif->p2p)
		    && !(priv->firmware_ps_mode.pmMode & WSM_PSM_FAST_PS)) {
			if (priv->setbssparams_done) {
				int ret = 0;
				struct wsm_set_pm pm = priv->powersave_mode;

				priv->powersave_mode.pmMode = WSM_PSM_FAST_PS;
				ret = xradio_set_pm(priv, &priv->powersave_mode);
				if (ret) {
					priv->powersave_mode = pm;
				}
			} else {
				priv->powersave_mode.pmMode = WSM_PSM_FAST_PS;
			}
		}
#endif
	}
#endif /*IPV6_FILTERING */

	if (changed & BSS_CHANGED_BEACON_ENABLED) {
		priv->enable_beacon = info->enable_beacon;
		ap_printk(XRADIO_DBG_NIY, "BSS_CHANGED_BEACON_ENABLED %s\n",
			priv->enable_beacon ? "enable" : "disable");
	}

	if (changed & BSS_CHANGED_BEACON) {
		ap_printk(XRADIO_DBG_NIY, "BSS_CHANGED_BEACON(enable=%d)\n",
			priv->enable_beacon);
		if (priv->enable_beacon) {
#ifdef HIDDEN_SSID
			if (priv->join_status != XRADIO_JOIN_STATUS_AP) {
				priv->hidden_ssid = info->hidden_ssid;
				priv->ssid_length = info->ssid_len;
				ap_printk(XRADIO_DBG_NIY, "hidden_ssid=%d, ssid_len=%zu\n",
					  info->hidden_ssid, info->ssid_len);
				if (info->ssid_len) {
					memcpy(priv->ssid, info->ssid, info->ssid_len);
					ap_printk(XRADIO_DBG_NIY, "ssid=%s\n", info->ssid);
				}
			} else
				ap_printk(XRADIO_DBG_NIY, "priv->join_status=%d\n",
					  priv->join_status);
#endif
			SYS_WARN(xradio_upload_beacon(priv));
			SYS_WARN(xradio_update_beaconing(priv));
		}
	}

	if (changed & BSS_CHANGED_BEACON_INT) {
		ap_printk(XRADIO_DBG_NIY, "CHANGED_BEACON_INT\n");
		/* Restart AP only when connected */
		if (priv->join_status == XRADIO_JOIN_STATUS_AP)
			SYS_WARN(xradio_update_beaconing(priv));
	}


	if (changed & BSS_CHANGED_ASSOC) {
		wsm_lock_tx(hw_priv);
		priv->wep_default_key_id = -1;
		wsm_unlock_tx(hw_priv);

		if (!info->assoc /* && !info->ibss_joined */) {
			priv->cqm_link_loss_count = XRADIO_LINK_LOSS_THOLD_DEF;
			priv->cqm_beacon_loss_count = XRADIO_BSS_LOSS_THOLD_DEF;
			priv->cqm_tx_failure_thold = 0;
		}
		priv->cqm_tx_failure_count = 0;
	}

	if (changed &
	    (BSS_CHANGED_ASSOC        |
	     BSS_CHANGED_BASIC_RATES  |
	     BSS_CHANGED_ERP_PREAMBLE |
	     BSS_CHANGED_HT           |
	     BSS_CHANGED_ERP_SLOT)) {
		int is_combo = 0;
		int i;
		struct xradio_vif *tmp_priv;
		ap_printk(XRADIO_DBG_NIY, "BSS_CHANGED_ASSOC.\n");
		/*Driver is already do unjoin.*/
		if (priv->if_id == 0 && priv->vif->type == NL80211_IFTYPE_STATION &&
			priv->join_status == XRADIO_JOIN_STATUS_PASSIVE) {
			changed &= ~BSS_CHANGED_ASSOC;
			ap_printk(XRADIO_DBG_WARN, "BSS_CHANGED_ASSOC but driver is unjoined.\n");
			mac80211_connection_loss(priv->vif);
		}
		/* TODO: ibss_joined */
		if (info->assoc && priv->join_status != XRADIO_JOIN_STATUS_PASSIVE) {
			struct ieee80211_sta *sta = NULL;

#ifdef SUPPORT_HT40
			struct phy_mode_cfg PhyModeCfg;
#endif
			if (info->dtim_period)
				priv->join_dtim_period = info->dtim_period;
			priv->beacon_int = info->beacon_int;

			/* Associated: kill join timeout */
			cancel_delayed_work(&priv->join_timeout);

			rcu_read_lock();
			if (info->bssid)
				sta = mac80211_find_sta(vif, info->bssid);
			if (sta) {
				/* TODO:COMBO:Change this once
				 * mac80211 changes are available */
				SYS_BUG(!hw_priv->channel);
				hw_priv->ht_info.ht_cap = sta->ht_cap;
				priv->bss_params.operationalRateSet =
				  __cpu_to_le32(xradio_rate_mask_to_wsm(hw_priv,
						sta->supp_rates[hw_priv->channel->band]));
				hw_priv->ht_info.channel_type   = chan_type;
				hw_priv->ht_info.operation_mode = info->ht_operation_mode;
				priv->oper_rates = sta->supp_rates[hw_priv->channel->band];
			} else {
				ap_printk(XRADIO_DBG_NIY, "BSS_CHANGED_ASSOC no sta.\n");
				memset(&hw_priv->ht_info, 0, sizeof(hw_priv->ht_info));
				priv->bss_params.operationalRateSet = -1;
				priv->oper_rates = -1;
			}
			rcu_read_unlock();
			priv->htcap = (sta && xradio_is_ht(&hw_priv->ht_info));
			xradio_for_each_vif(hw_priv, tmp_priv, i) {
#ifdef P2P_MULTIVIF
				if ((i == (XRWL_MAX_VIFS - 1)) || !tmp_priv)
#else
				if (!tmp_priv)
#endif
					continue;
				if (tmp_priv->join_status >= XRADIO_JOIN_STATUS_STA)
					is_combo++;
			}

			if (is_combo > 1) {
				hw_priv->vif0_throttle = XRWL_HOST_VIF0_11BG_THROTTLE;
				hw_priv->vif1_throttle = XRWL_HOST_VIF1_11BG_THROTTLE;
				ap_printk(XRADIO_DBG_WARN, "%sASSOC is_combo %d\n",
					 (priv->join_status == XRADIO_JOIN_STATUS_STA) ?
					  "[STA] " : "", hw_priv->vif0_throttle);
			} else if ((priv->join_status == XRADIO_JOIN_STATUS_STA)
				   && priv->htcap) {
				hw_priv->vif0_throttle = XRWL_HOST_VIF0_11N_THROTTLE;
				hw_priv->vif1_throttle = XRWL_HOST_VIF1_11N_THROTTLE;
				ap_printk(XRADIO_DBG_WARN, "[STA] ASSOC HTCAP 11N %d\n",
					  hw_priv->vif0_throttle);
			} else {
				hw_priv->vif0_throttle = XRWL_HOST_VIF0_11BG_THROTTLE;
				hw_priv->vif1_throttle = XRWL_HOST_VIF1_11BG_THROTTLE;
				ap_printk(XRADIO_DBG_WARN, "ASSOC not_combo 11BG %d\n",
					  hw_priv->vif0_throttle);
			}

			if (sta) {

#ifdef SUPPORT_HT40

				__le32 ht_prot = 0;

				if (hw_priv->ht_info.operation_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT)
					ht_prot |= cpu_to_le32(WSM_NON_GREENFIELD_STA);

				ht_prot |= cpu_to_le32((hw_priv->ht_info.operation_mode & IEEE80211_HT_OP_MODE_PROTECTION) << 2);

				ap_printk(XRADIO_DBG_WARN, "[HT40][%s]" \
					"[ht_prot:0x%08x][HtProtMode:0x%04x]" \
					"[Green:0x%04x]",
					__func__, ht_prot,
					hw_priv->ht_info.operation_mode & IEEE80211_HT_OP_MODE_PROTECTION,
					hw_priv->ht_info.operation_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT);

				WARN_ON(wsm_write_mib(hw_priv,
					WSM_MID_ID_SET_HT_PROTECTION,
					&ht_prot, sizeof(ht_prot), priv->if_id));

#else

				__le32 val = 0;
				if (hw_priv->ht_info.operation_mode &
				    IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT) {
					ap_printk(XRADIO_DBG_NIY, "[STA] Non-GF STA present\n");
					/* Non Green field capable STA */
					val = __cpu_to_le32(BIT(1));
				}
				SYS_WARN(wsm_write_mib(hw_priv, WSM_MID_ID_SET_HT_PROTECTION,
						       &val, sizeof(val), priv->if_id));

#endif

			}

#ifdef SUPPORT_HT40

			PhyModeCfg.BandCfg = hw_priv->channel->band;

			if (PhyModeCfg.BandCfg == NL80211_BAND_5GHZ)
				PhyModeCfg.ModemFlags = (MODEM_F_A_OFDM|MODEM_F_N_OFDM);
			else
				PhyModeCfg.ModemFlags = (MODEM_F_B_DSSS|MODEM_F_A_OFDM|MODEM_F_N_OFDM);

			if (chan_type == NL80211_CHAN_HT40MINUS) {
				PhyModeCfg.ChWidthCfg = CHAN_WIDTH_40MHz;
				PhyModeCfg.PriChCfg   = PRIMARY_CH_1ST;
			} else if (chan_type == NL80211_CHAN_HT40PLUS) {
				PhyModeCfg.ChWidthCfg = CHAN_WIDTH_40MHz;
				PhyModeCfg.PriChCfg   = PRIMARY_CH_2ND;
			} else {
				PhyModeCfg.ChWidthCfg = CHAN_WIDTH_20MHz;
				PhyModeCfg.PriChCfg   = PRIMARY_CH_1ST;
			}

			if (chan_type == NL80211_CHAN_NO_HT) {
				PhyModeCfg.ModemFlags &= ~(MODEM_F_N_OFDM);
				PhyModeCfg.SGI_Enable = false;
				PhyModeCfg.GF_Enable = false;
			} else {
				PhyModeCfg.SGI_Enable = xradio_ht_ShortGI(&hw_priv->ht_info);
				PhyModeCfg.GF_Enable  = xradio_ht_greenfield(&hw_priv->ht_info);
			}

			PhyModeCfg.STBC_Enable = false;
			PhyModeCfg.PreambleCfg = info->use_short_preamble ?
				WSM_JOIN_PREAMBLE_SHORT :
				WSM_JOIN_PREAMBLE_LONG;

			priv->association_mode.PhyModeCfg = PhyModeCfg;

			priv->association_mode.flags =
				WSM_ASSOCIATION_MODE_USE_PHY_MODE_CFG |
				WSM_ASSOCIATION_MODE_USE_BASIC_RATE_SET |
				WSM_ASSOCIATION_MODE_USE_MPDU_START_SPACING;

#else
			priv->association_mode.greenfieldMode =
			    xradio_ht_greenfield(&hw_priv->ht_info);
			priv->association_mode.flags =
			    WSM_ASSOCIATION_MODE_SNOOP_ASSOC_FRAMES |
			    WSM_ASSOCIATION_MODE_USE_PREAMBLE_TYPE |
			    WSM_ASSOCIATION_MODE_USE_HT_MODE |
			    WSM_ASSOCIATION_MODE_USE_BASIC_RATE_SET |
			    WSM_ASSOCIATION_MODE_USE_MPDU_START_SPACING;

			priv->association_mode.preambleType =
			  (info->use_short_preamble ? WSM_JOIN_PREAMBLE_SHORT :
			   WSM_JOIN_PREAMBLE_LONG);

#endif

			priv->association_mode.basicRateSet =
			    __cpu_to_le32(xradio_rate_mask_to_wsm(hw_priv,
					  info->basic_rates));
			priv->base_rates = info->basic_rates;
			priv->association_mode.mpduStartSpacing =
			    xradio_ht_ampdu_density(&hw_priv->ht_info);

#if defined(CONFIG_XRADIO_USE_EXTENSIONS)
			priv->cqm_beacon_loss_count = 0; //info->cqm_beacon_miss_thold;
			priv->cqm_tx_failure_thold = 0; //info->cqm_tx_fail_thold;
			priv->cqm_tx_failure_count = 0;
			cancel_delayed_work_sync(&priv->bss_loss_work);
			cancel_delayed_work_sync(&priv->connection_loss_work);
#endif /* CONFIG_XRADIO_USE_EXTENSIONS */

			priv->bss_params.beaconLostCount = (priv->cqm_beacon_loss_count ?
			  priv->cqm_beacon_loss_count : priv->cqm_link_loss_count);

			priv->bss_params.aid = info->aid;

			if (priv->join_dtim_period < 1)
				priv->join_dtim_period = 1;

#ifdef SUPPORT_HT40

			ap_printk(XRADIO_DBG_WARN, "[HT40][%s]"\
				"[PhyModeCfg:0x%04x]\n"\
				"[ModemFlags    :0x%08x]\n"\
				"[ChWidthCfg    :0x%08x]\n"\
				"[PriChCfg      :0x%08x]\n"\
				"[BandCfg       :0x%08x]\n"\
				"[STBC_Enable   :0x%08x]\n"\
				"[PreambleCfg   :0x%08x]\n"\
				"[SGI_Enable    :0x%08x]\n"\
				"[GF_Enable     :0x%08x]\n",
				__func__,
				*(u16 *)&(priv->association_mode.PhyModeCfg),
				priv->association_mode.PhyModeCfg.ModemFlags,
				priv->association_mode.PhyModeCfg.ChWidthCfg,
				priv->association_mode.PhyModeCfg.PriChCfg,
				priv->association_mode.PhyModeCfg.BandCfg,
				priv->association_mode.PhyModeCfg.STBC_Enable,
				priv->association_mode.PhyModeCfg.PreambleCfg,
				priv->association_mode.PhyModeCfg.SGI_Enable,
				priv->association_mode.PhyModeCfg.GF_Enable);

			ap_printk(XRADIO_DBG_MSG, "[STA] DTIM %d, "\
				"interval: %d\n",
				priv->join_dtim_period, priv->beacon_int);

			ap_printk(XRADIO_DBG_MSG, "[STA] Preamble: %d, "\
				"Greenfield: %d, Aid: %d, "\
				"Rates: 0x%.8X, Basic: 0x%.8X\n",
				priv->association_mode.PhyModeCfg.PreambleCfg,
				priv->association_mode.PhyModeCfg.GF_Enable,
				priv->bss_params.aid,
				priv->bss_params.operationalRateSet,
				priv->association_mode.basicRateSet);

#else

			ap_printk(XRADIO_DBG_MSG, "[STA] DTIM %d, interval: %d\n",
				  priv->join_dtim_period, priv->beacon_int);
			ap_printk(XRADIO_DBG_MSG, "[STA] Preamble: %d, " \
				  "Greenfield: %d, Aid: %d, " \
				  "Rates: 0x%.8X, Basic: 0x%.8X\n",
				  priv->association_mode.preambleType,
				  priv->association_mode.greenfieldMode,
				  priv->bss_params.aid,
				  priv->bss_params.operationalRateSet,
				  priv->association_mode.basicRateSet);

#endif

			SYS_WARN(wsm_set_association_mode(hw_priv,
				 &priv->association_mode, priv->if_id));
			SYS_WARN(wsm_keep_alive_period(hw_priv,
						       XRADIO_KEEP_ALIVE_PERIOD /* sec */,
						       priv->if_id));
			SYS_WARN(wsm_set_bss_params(hw_priv,
				 &priv->bss_params, priv->if_id));
			priv->setbssparams_done = true;
#ifdef XRADIO_USE_LONG_DTIM_PERIOD
			{
				int join_dtim_period_extend;
				if (priv->join_dtim_period <= 3) {
					join_dtim_period_extend = priv->join_dtim_period * 3;
				} else if (priv->join_dtim_period <= 5) {
					join_dtim_period_extend = priv->join_dtim_period * 2;
				} else {
					join_dtim_period_extend = priv->join_dtim_period;
				}
				SYS_WARN(wsm_set_beacon_wakeup_period(hw_priv,
					((priv->beacon_int * join_dtim_period_extend) >
					MAX_BEACON_SKIP_TIME_MS ?
					1 : join_dtim_period_extend), 0, priv->if_id));
			}
#else
			SYS_WARN(wsm_set_beacon_wakeup_period(hw_priv,
				 ((priv->beacon_int * priv->join_dtim_period) >
				 MAX_BEACON_SKIP_TIME_MS ?
				 1 : priv->join_dtim_period), 0, priv->if_id));
#endif
			if (priv->htcap) {
				wsm_lock_tx(hw_priv);
				/* Statically enabling block ack for TX/RX */
				SYS_WARN(wsm_set_block_ack_policy(hw_priv,
					 hw_priv->ba_tid_mask, hw_priv->ba_tid_mask,
					 priv->if_id));
				wsm_unlock_tx(hw_priv);
			}
			if (priv->filter4.enable || !(priv->powersave_mode.pmMode&WSM_PSM_PS)) {
				xradio_set_pm(priv, &priv->powersave_mode);
			}
			if (priv->vif->p2p) {
				ap_printk(XRADIO_DBG_NIY,
					  "[STA] Setting p2p powersave configuration.\n");
				SYS_WARN(wsm_set_p2p_ps_modeinfo(hw_priv,
					 &priv->p2p_ps_modeinfo, priv->if_id));
#if defined(CONFIG_XRADIO_USE_EXTENSIONS)
				xradio_notify_noa(priv, XRADIO_NOA_NOTIFICATION_DELAY);
#endif
			}

			if (priv->mode == NL80211_IFTYPE_STATION ||
				priv->mode == NL80211_IFTYPE_P2P_DEVICE)
				SYS_WARN(xradio_upload_qosnull(priv));

			if (hw_priv->is_BT_Present)
				SYS_WARN(xradio_set_btcoexinfo(priv));
#if 0
			/* It's better to override internal TX rete; otherwise
			 * device sends RTS at too high rate. However device
			 * can't receive CTS at 1 and 2 Mbps. Well, 5.5 is a
			 * good choice for RTS/CTS, but that means PS poll
			 * will be sent at the same rate - impact on link
			 * budget. Not sure what is better.. */

			/* Update: internal rate selection algorythm is not
			 * bad: if device is not receiving CTS at high rate,
			 * it drops RTS rate.
			 * So, conclusion: if-0 the code. Keep code just for
			 * information:
			 * Do not touch WSM_MIB_ID_OVERRIDE_INTERNAL_TX_RATE! */

			/* ~3 is a bug in device: RTS/CTS is not working at
			 * low rates */
			__le32 internal_tx_rate =
			    __cpu_to_le32(__ffs(priv->association_mode.basicRateSet & ~3));
			SYS_WARN(wsm_write_mib(priv, WSM_MIB_ID_OVERRIDE_INTERNAL_TX_RATE,
				 &internal_tx_rate, sizeof(internal_tx_rate)));
#endif
		} else {
			ap_printk(XRADIO_DBG_NIY, "BSS_CHANGED_ASSOC not assoc, change=0x%08x.\n", changed);
			memset(&priv->association_mode, 0, sizeof(priv->association_mode));
			memset(&priv->bss_params, 0, sizeof(priv->bss_params));
			priv->base_rates = -1;
			priv->oper_rates = -1;
		}
	}
	if (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_ERP_CTS_PROT)) {
		u32 prev_erp_info = priv->erp_info;
		if (priv->join_status == XRADIO_JOIN_STATUS_AP) {
			if (info->use_cts_prot)
				priv->erp_info |= WLAN_ERP_USE_PROTECTION;
			else if (!(prev_erp_info & WLAN_ERP_NON_ERP_PRESENT))
				priv->erp_info &= ~WLAN_ERP_USE_PROTECTION;

			if (prev_erp_info != priv->erp_info)
				queue_delayed_work(hw_priv->workqueue,
						   &priv->set_cts_work, 0*HZ);
		}
	}

	if (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_ERP_SLOT)) {
		__le32 slot_time = info->use_short_slot ?
				   __cpu_to_le32(9) : __cpu_to_le32(20);
		ap_printk(XRADIO_DBG_MSG, "[STA] Slot time :%d us.\n",
			  __le32_to_cpu(slot_time));
		SYS_WARN(wsm_write_mib(hw_priv, WSM_MIB_ID_DOT11_SLOT_TIME,
				       &slot_time, sizeof(slot_time), priv->if_id));
	}
	if (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_CQM)) {
		struct wsm_rcpi_rssi_threshold threshold = {
			.rollingAverageCount = 8,
		};

#if 0
		/* For verification purposes */
		info->cqm_rssi_thold = -50;
		info->cqm_rssi_hyst = 4;
#endif /* 0 */

		ap_printk(XRADIO_DBG_NIY,
			  "[CQM] RSSI threshold subscribe: %d(+-%d)\n",
			  info->cqm_rssi_thold, info->cqm_rssi_hyst);

#if defined(CONFIG_XRADIO_USE_EXTENSIONS)
		//ap_printk(XRADIO_DBG_NIY, "[CQM] Beacon loss subscribe: %d\n",
			  //info->cqm_beacon_miss_thold);
		//ap_printk(XRADIO_DBG_NIY, "[CQM] TX failure subscribe: %d\n",
			  //info->cqm_tx_fail_thold);
		priv->cqm_rssi_thold = info->cqm_rssi_thold;
		priv->cqm_rssi_hyst  = info->cqm_rssi_hyst;
#endif /* CONFIG_XRADIO_USE_EXTENSIONS */

		if (info->cqm_rssi_thold || info->cqm_rssi_hyst) {
			/* RSSI subscription enabled */
			/* TODO: It's not a correct way of setting threshold.
			 * Upper and lower must be set equal here and adjusted
			 * in callback. However current implementation is much
			 * more relaible and stable. */
			if (priv->cqm_use_rssi) {
				threshold.upperThreshold = info->cqm_rssi_thold +
							   info->cqm_rssi_hyst;
				threshold.lowerThreshold = info->cqm_rssi_thold;
			} else {
				/* convert RSSI to RCPI, RCPI = (RSSI + 110) * 2 */
				threshold.upperThreshold = (info->cqm_rssi_thold +
							    info->cqm_rssi_hyst + 110)<<1;
				threshold.lowerThreshold = (info->cqm_rssi_thold + 110)<<1;
			}
			threshold.rssiRcpiMode |= WSM_RCPI_RSSI_THRESHOLD_ENABLE;
		} else {
			/* There is a bug in FW, see sta.c. We have to enable
			 * dummy subscription to get correct RSSI values. */
			threshold.rssiRcpiMode |= WSM_RCPI_RSSI_THRESHOLD_ENABLE |
						  WSM_RCPI_RSSI_DONT_USE_UPPER   |
						  WSM_RCPI_RSSI_DONT_USE_LOWER;
		}
		SYS_WARN(wsm_set_rcpi_rssi_threshold(hw_priv, &threshold, priv->if_id));

#if defined(CONFIG_XRADIO_USE_EXTENSIONS)
#if 0
		//priv->cqm_tx_failure_thold = info->cqm_tx_fail_thold;
		priv->cqm_tx_failure_count = 0;
		if (priv->cqm_beacon_loss_count != info->cqm_beacon_miss_thold) {
			priv->cqm_beacon_loss_count = info->cqm_beacon_miss_thold;
			priv->bss_params.beaconLostCount = (priv->cqm_beacon_loss_count ?
			  priv->cqm_beacon_loss_count : priv->cqm_link_loss_count);
			/* Make sure we are associated before sending
			 * set_bss_params to firmware */
			if (priv->bss_params.aid) {
				SYS_WARN(wsm_set_bss_params(hw_priv,
					 &priv->bss_params, priv->if_id));
				priv->setbssparams_done = true;
			}
		}
#endif
#endif /* CONFIG_XRADIO_USE_EXTENSIONS */
	}

	if (changed & BSS_CHANGED_PS) {
		//if (info->ps_enabled == false)
		//if ((dev->conf.flags & IEEE80211_CONF_PS) == 0)
		if (vif->bss_conf.ps == false)
			priv->powersave_mode.pmMode = WSM_PSM_ACTIVE;
		//else if (info->dynamic_ps_timeout <= 0)
		else if (dev->conf.dynamic_ps_timeout <= 0)
			priv->powersave_mode.pmMode = WSM_PSM_PS;
		else
			priv->powersave_mode.pmMode = WSM_PSM_FAST_PS;

		ap_printk(XRADIO_DBG_MSG, "[STA] Aid: %d, Joined: %s, Powersave: %s\n",
		   priv->bss_params.aid,
		   priv->join_status == XRADIO_JOIN_STATUS_STA ? "yes" : "no",
		  (priv->powersave_mode.pmMode == WSM_PSM_ACTIVE ? "WSM_PSM_ACTIVE" :
		   priv->powersave_mode.pmMode == WSM_PSM_PS ? "WSM_PSM_PS" :
		   priv->powersave_mode.pmMode == WSM_PSM_FAST_PS ? "WSM_PSM_FAST_PS" :
						  "UNKNOWN"));

		/* Firmware requires that value for this 1-byte field must
		 * be specified in units of 500us. Values above the 128ms
		 * threshold are not supported. */
		if (dev->conf.dynamic_ps_timeout >= 0x80)
			priv->powersave_mode.fastPsmIdlePeriod = 0xFF;
		else
			priv->powersave_mode.fastPsmIdlePeriod =
					     dev->conf.dynamic_ps_timeout << 1;
		ap_printk(XRADIO_DBG_NIY,
			  "[STA]CHANGED_PS fastPsmIdle=%d, apPsmChange=%d\n",
			  priv->powersave_mode.fastPsmIdlePeriod,
			  priv->powersave_mode.apPsmChangePeriod);

		if (priv->join_status == XRADIO_JOIN_STATUS_STA
		    && priv->bss_params.aid
		    && priv->setbssparams_done && priv->filter4.enable)
			xradio_set_pm(priv, &priv->powersave_mode);
		else
			priv->power_set_true = 1;
	}

#if defined(CONFIG_XRADIO_USE_EXTENSIONS)
	if (changed & BSS_CHANGED_P2P_PS) {
		struct wsm_p2p_ps_modeinfo *modeinfo;
		modeinfo = &priv->p2p_ps_modeinfo;
		ap_printk(XRADIO_DBG_NIY, "[AP] BSS_CHANGED_P2P_PS\n");
#if 0
		ap_printk(XRADIO_DBG_NIY,
			  "[AP] Legacy PS: %d for AID %d in %d mode.\n",
			  info->p2p_ps.legacy_ps, priv->bss_params.aid,
			  priv->join_status);

		if (info->p2p_ps.legacy_ps >= 0) {
			if (info->p2p_ps.legacy_ps > 0)
				priv->powersave_mode.pmMode = WSM_PSM_PS;
			else
				priv->powersave_mode.pmMode = WSM_PSM_ACTIVE;

			if (info->p2p_ps.ctwindow && info->p2p_ps.opp_ps)
				priv->powersave_mode.pmMode = WSM_PSM_PS;
			if (priv->join_status == XRADIO_JOIN_STATUS_STA)
				xradio_set_pm(priv, &priv->powersave_mode);
		}

		ap_printk(XRADIO_DBG_MSG, "[AP] CTWindow: %d\n",
			  info->p2p_ps.ctwindow);
		if (info->p2p_ps.ctwindow >= 128)
			modeinfo->oppPsCTWindow = 127;
		else if (info->p2p_ps.ctwindow >= 0)
			modeinfo->oppPsCTWindow = info->p2p_ps.ctwindow;

		ap_printk(XRADIO_DBG_MSG, "[AP] Opportunistic: %d\n",
			  info->p2p_ps.opp_ps);
		switch (info->p2p_ps.opp_ps) {
		case 0:
			modeinfo->oppPsCTWindow &= ~(BIT(7));
			break;
		case 1:
			modeinfo->oppPsCTWindow |= BIT(7);
			break;
		default:
			break;
		}

		ap_printk(XRADIO_DBG_MSG, "[AP] NOA: %d, %d, %d, %d\n",
			  info->p2p_ps.count, info->p2p_ps.start,
			  info->p2p_ps.duration, info->p2p_ps.interval);
		/* Notice of Absence */
		modeinfo->count = info->p2p_ps.count;

		if (info->p2p_ps.count) {
			/* In case P2P_GO we need some extra time to be sure
			 * we will update beacon/probe_resp IEs correctly */
#define NOA_DELAY_START_MS	300
			if (priv->join_status == XRADIO_JOIN_STATUS_AP)
				modeinfo->startTime =
				    __cpu_to_le32(info->p2p_ps.start + NOA_DELAY_START_MS);
			else
				modeinfo->startTime = __cpu_to_le32(info->p2p_ps.start);
			modeinfo->duration    = __cpu_to_le32(info->p2p_ps.duration);
			modeinfo->interval    = __cpu_to_le32(info->p2p_ps.interval);
			modeinfo->dtimCount   = 1;
			modeinfo->reserved    = 0;
		} else {
			modeinfo->dtimCount = 0;
			modeinfo->startTime = 0;
			modeinfo->reserved  = 0;
			modeinfo->duration  = 0;
			modeinfo->interval  = 0;
		}
#endif

#if defined(CONFIG_XRADIO_DEBUG)
		print_hex_dump_bytes("p2p_set_ps_modeinfo: ", DUMP_PREFIX_NONE,
				     (u8 *)modeinfo, sizeof(*modeinfo));
#endif /* CONFIG_XRADIO_DEBUG */

		if (priv->join_status == XRADIO_JOIN_STATUS_STA ||
		    priv->join_status == XRADIO_JOIN_STATUS_AP) {
			SYS_WARN(wsm_set_p2p_ps_modeinfo(hw_priv, modeinfo, priv->if_id));
		}
#if defined(CONFIG_XRADIO_USE_EXTENSIONS)
		/* Temporary solution while firmware don't support NOA change
		 * notification yet */
		xradio_notify_noa(priv, 10);
#endif
	}
#endif /* CONFIG_XRADIO_USE_EXTENSIONS */

	up(&hw_priv->conf_lock);
}

void xradio_multicast_start_work(struct work_struct *work)
{
	struct xradio_vif *priv =
	    container_of(work, struct xradio_vif, multicast_start_work);
	long tmo = priv->join_dtim_period * (priv->beacon_int + 20) * HZ / 1024;

	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	cancel_work_sync(&priv->multicast_stop_work);
	if (!priv->aid0_bit_set) {
		wsm_lock_tx(priv->hw_priv);
		xradio_set_tim_impl(priv, true);
		priv->aid0_bit_set = true;
		mod_timer(&priv->mcast_timeout, jiffies + tmo);
		wsm_unlock_tx(priv->hw_priv);
	}
}

void xradio_multicast_stop_work(struct work_struct *work)
{
	struct xradio_vif *priv =
	    container_of(work, struct xradio_vif, multicast_stop_work);
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	if (priv->aid0_bit_set) {
		del_timer_sync(&priv->mcast_timeout);
		wsm_lock_tx(priv->hw_priv);
		priv->aid0_bit_set = false;
		xradio_set_tim_impl(priv, false);
		wsm_unlock_tx(priv->hw_priv);
	}
}

void xradio_mcast_timeout(struct timer_list *t)
{
	struct xradio_vif *priv = from_timer(priv, t, mcast_timeout);
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	ap_printk(XRADIO_DBG_WARN, "Multicast delivery timeout.\n");
	spin_lock_bh(&priv->ps_state_lock);
	priv->tx_multicast = priv->aid0_bit_set && priv->buffered_multicasts;
	if (priv->tx_multicast)
		xradio_proc_wakeup(xrwl_vifpriv_to_hwpriv(priv));
	spin_unlock_bh(&priv->ps_state_lock);
}

int xradio_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
			struct ieee80211_ampdu_params *params)
{
	/* Aggregation is implemented fully in firmware,
	 * including block ack negotiation.
	 * In case of AMPDU aggregation in RX direction
	 * re-ordering of packets takes place on host. mac80211
	 * needs the ADDBA Request to setup reodering.mac80211 also
	 * sends ADDBA Response which is discarded in the driver as
	 * FW generates the ADDBA Response on its own.*/
	int ret;
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	switch (params->action) {
	case IEEE80211_AMPDU_RX_START:
	case IEEE80211_AMPDU_RX_STOP:
		/* Just return OK to mac80211 */
		ret = 0;
		break;
	default:
		ret = -ENOTSUPP;
	}
	return ret;
}

/* ******************************************************************** */
/* WSM callback								*/
void xradio_suspend_resume(struct xradio_vif *priv,
			   struct wsm_suspend_resume *arg)
{
	struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

#if 0
	ap_printk(XRADIO_DBG_MSG, "[AP] %s: %s\n",
		  arg->stop ? "stop" : "start",
		  arg->multicast ? "broadcast" : "unicast");
#endif
	if (arg->multicast) {
		bool cancel_tmo = false;
		spin_lock_bh(&priv->ps_state_lock);
		if (arg->stop) {
			priv->tx_multicast = false;
		} else {
			/* Firmware sends this indication every DTIM if there
			 * is a STA in powersave connected. There is no reason
			 * to suspend, following wakeup will consume much more
			 * power than it could be saved. */
#ifdef CONFIG_PM
#ifndef CONFIG_XRADIO_SUSPEND_POWER_OFF
			xradio_pm_stay_awake(&hw_priv->pm_state,
					     (priv->join_dtim_period * \
					     (priv->beacon_int + 20) * HZ / 1024));
#endif
#endif
			priv->tx_multicast = priv->aid0_bit_set &&
					     priv->buffered_multicasts;
			if (priv->tx_multicast) {
				cancel_tmo = true;
				xradio_proc_wakeup(hw_priv);
			}
		}
		spin_unlock_bh(&priv->ps_state_lock);
		if (cancel_tmo)
			del_timer_sync(&priv->mcast_timeout);
	} else {
		spin_lock_bh(&priv->ps_state_lock);
		xradio_ps_notify(priv, arg->link_id, arg->stop);
		spin_unlock_bh(&priv->ps_state_lock);
		if (!arg->stop)
			xradio_proc_wakeup(hw_priv);
	}
	return;
}

/* ******************************************************************** */
/* AP privates								*/

static int xradio_upload_beacon(struct xradio_vif *priv)
{
	int ret = 0;
	struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
	struct wsm_template_frame frame = {
		.frame_type = WSM_FRAME_TYPE_BEACON,
	};
	struct ieee80211_mgmt *mgmt;
	u8 *erp_inf, *ies, *ht_info;
	u32 ies_len;
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

#ifdef SUPPORT_HT40

	frame.rate = ((RATE_MODEM_LEGACY  << MODEMTYPE_SHIFT) |
				(RATE_BANDWIDTH_20M << BANDWIDTH_SHIFT));
	if (priv->vif->p2p || hw_priv->channel->band == NL80211_BAND_5GHZ)
		frame.rate |= (A_RATES_OFF << RATEINDEX_SHIFT);

#else

	if (priv->vif->p2p || hw_priv->channel->band == NL80211_BAND_5GHZ)
		frame.rate = WSM_TRANSMIT_RATE_6;

#endif

	frame.skb = ieee80211_beacon_get(priv->hw, priv->vif);
	if (SYS_WARN(!frame.skb))
		return -ENOMEM;

	mgmt = (void *)frame.skb->data;
	ies = mgmt->u.beacon.variable;
	ies_len = frame.skb->len - (u32) (ies - (u8 *) mgmt);

	ht_info = (u8 *)cfg80211_find_ie(WLAN_EID_HT_INFORMATION, ies, ies_len);
	if (ht_info) {
		/* Enable RIFS */
		ht_info[3] |= 8;
	}

	erp_inf = (u8 *)cfg80211_find_ie(WLAN_EID_ERP_INFO, ies, ies_len);
	if (erp_inf) {
		if (erp_inf[ERP_INFO_BYTE_OFFSET]
				& WLAN_ERP_BARKER_PREAMBLE)
			priv->erp_info |= WLAN_ERP_BARKER_PREAMBLE;
		else
			priv->erp_info &= ~WLAN_ERP_BARKER_PREAMBLE;

		if (erp_inf[ERP_INFO_BYTE_OFFSET]
				& WLAN_ERP_NON_ERP_PRESENT) {
			ap_printk(XRADIO_DBG_NIY, "WLAN_ERP_NON_ERP_PRESENT.\n");
			priv->erp_info |= WLAN_ERP_USE_PROTECTION;
			priv->erp_info |= WLAN_ERP_NON_ERP_PRESENT;
		} else {
			ap_printk(XRADIO_DBG_NIY, "No WLAN_ERP_NON_ERP_PRESENT.\n");
			priv->erp_info &= ~WLAN_ERP_USE_PROTECTION;
			priv->erp_info &= ~WLAN_ERP_NON_ERP_PRESENT;
		}
	}

#ifdef HIDDEN_SSID
	if (priv->hidden_ssid) {
		u8 *ssid_ie;
		u8 ssid_len;
		/*
		 * Hidden ap set by two ways:
		 * 1. ssid len != 0, and ssid filled with zero.
		 * 2. ssid len = 0, and no ssid in beacon or probe_resp.
		 */
		ap_printk(XRADIO_DBG_NIY, "%s: hidden_ssid set\n", __func__);
		ssid_ie = (u8 *) cfg80211_find_ie(WLAN_EID_SSID, ies, ies_len);
		SYS_WARN(!ssid_ie);
		ssid_len = ssid_ie[1];
		if (ssid_len) {
			ap_printk(XRADIO_DBG_MSG, "hidden_ssid with zero content ssid\n");
			ssid_ie[1] = 0;
			memmove(ssid_ie + 2, ssid_ie + 2 + ssid_len,
				(ies + ies_len - (ssid_ie + 2 + ssid_len)));
			frame.skb->len -= ssid_len;
		} else {
			ap_printk(XRADIO_DBG_NIY,
				  "hidden ssid with ssid len 0, we have nothing to do!");
		}
	}
#endif

	ret = wsm_set_template_frame(hw_priv, &frame, priv->if_id);
	if (!ret) {
#ifdef PROBE_RESP_EXTRA_IE
		ret = xradio_upload_proberesp(priv);
#else
		/* TODO: Distille probe resp; remove TIM
		 * and other beacon-specific IEs */
		*(__le16 *)frame.skb->data =
		    __cpu_to_le16(IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_PROBE_RESP);
		frame.frame_type = WSM_FRAME_TYPE_PROBE_RESPONSE;
		/* TODO: Ideally probe response template should separately
		   configured by supplicant through openmac. This is a
		   temporary work-around known to fail p2p group info
		   attribute related tests
		 */
		if (0 /* priv->vif->p2p */)
			ret = wsm_set_probe_responder(priv, true);
		else {
			ret = wsm_set_template_frame(hw_priv, &frame, priv->if_id);
			SYS_WARN(wsm_set_probe_responder(priv, false));
		}
#endif
	}
	dev_kfree_skb(frame.skb);

	return ret;
}

#ifdef PROBE_RESP_EXTRA_IE
static int xradio_upload_proberesp(struct xradio_vif *priv)
{
	int ret = 0;
	struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
	struct wsm_template_frame frame = {
		.frame_type = WSM_FRAME_TYPE_PROBE_RESPONSE,
	};
#ifdef HIDDEN_SSID
	u8 *ssid_ie;
#endif
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

#ifdef SUPPORT_HT40

	frame.rate = ((RATE_MODEM_LEGACY  << MODEMTYPE_SHIFT) |
				(RATE_BANDWIDTH_20M << BANDWIDTH_SHIFT));
	if (priv->vif->p2p || hw_priv->channel->band == NL80211_BAND_5GHZ)
		frame.rate |= (A_RATES_OFF << RATEINDEX_SHIFT);

#else

	if (priv->vif->p2p || hw_priv->channel->band == NL80211_BAND_5GHZ)
		frame.rate = WSM_TRANSMIT_RATE_6;

#endif

	frame.skb = mac80211_proberesp_get(priv->hw, priv->vif);
	if (frame.skb == NULL) {
		frame.skb = mac80211_proberesp_ext_get(priv->hw, priv->vif);
		if (frame.skb == NULL) {
			ap_printk(XRADIO_DBG_ERROR, "mac80211_proberesp_ext_get frame.skb is null");
			return -ENOMEM;
		}
	}
	if (SYS_WARN(!frame.skb))
		return -ENOMEM;

#ifdef HIDDEN_SSID
	if (priv->hidden_ssid) {
		int offset;
		u8 ssid_len;
		/* we are assuming beacon from upper layer will always contain
		 * zero filled ssid for hidden ap. The beacon shall never have
		 * ssid len = 0.
		 */
		/* Upper layer will set ssid len = 0 for for hidden ap too.
		 * --13:23 2017/1/9
		 */

		offset  = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
		ssid_ie = (u8 *)cfg80211_find_ie(WLAN_EID_SSID,
						 frame.skb->data + offset,
						 frame.skb->len - offset);
		if (!ssid_ie) {
			ap_printk(XRADIO_DBG_ERROR,
					  "%s:ssid is not found in probe_resp\n", __func__);
			dev_kfree_skb(frame.skb);
			return -1;
		}

		if (!priv->ssid_length) {
			ap_printk(XRADIO_DBG_ERROR,
				  "%s:hidden ssid is Not config yet.\n", __func__);
			dev_kfree_skb(frame.skb);
			return -1;
		} else {
			ap_printk(XRADIO_DBG_NIY,
				  "%s: hidden ssid in probe_resp=%s\n",
				  __func__, priv->ssid);
		}

		ssid_len = ssid_ie[1];
		if (ssid_len) {
			if (ssid_len == priv->ssid_length) {
				memcpy(ssid_ie + 2, priv->ssid, ssid_len);
			} else {
				ap_printk(XRADIO_DBG_ERROR,
					  "%s: hidden ssid with mismatched ssid_len %d\n",
					  __func__, ssid_len);
				dev_kfree_skb(frame.skb);
				return -1;
			}
		} else {
			if (skb_tailroom(frame.skb) >= priv->ssid_length) {
				u8 move_len = (frame.skb->data +
						frame.skb->len) - (ssid_ie + 2);
				skb_put(frame.skb, priv->ssid_length);
				ssid_ie[1] = priv->ssid_length;
				memmove(&ssid_ie[2 + priv->ssid_length],
						&ssid_ie[2], move_len);
				memcpy(&ssid_ie[2], priv->ssid, priv->ssid_length);
			} else {
				ap_printk(XRADIO_DBG_ERROR,
				  "%s: no room in probe_resp for hidden ssid len=%zu\n",
				  __func__, priv->ssid_length);
				dev_kfree_skb(frame.skb);
				return -1;
			}
		}
	}
#endif
	ret = wsm_set_template_frame(hw_priv, &frame,  priv->if_id);
	SYS_WARN(wsm_set_probe_responder(priv, false));

	dev_kfree_skb(frame.skb);

	return ret;
}
#endif

static int xradio_upload_pspoll(struct xradio_vif *priv)
{
	int ret = 0;
	struct wsm_template_frame frame = {
		.frame_type = WSM_FRAME_TYPE_PS_POLL,
		.rate = 0xFF,
	};
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	frame.skb = mac80211_pspoll_get(priv->hw, priv->vif);
	if (SYS_WARN(!frame.skb))
		return -ENOMEM;
	ret = wsm_set_template_frame(xrwl_vifpriv_to_hwpriv(priv),
				     &frame, priv->if_id);
	dev_kfree_skb(frame.skb);
	return ret;
}

static int xradio_upload_null(struct xradio_vif *priv)
{
	int ret = 0;
	struct wsm_template_frame frame = {
		.frame_type = WSM_FRAME_TYPE_NULL,
		.rate = 0xFF,
	};
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	frame.skb = mac80211_nullfunc_get(priv->hw, priv->vif, false);

	if (SYS_WARN(!frame.skb))
		return -ENOMEM;

	ret = wsm_set_template_frame(xrwl_vifpriv_to_hwpriv(priv),
				     &frame, priv->if_id);
	dev_kfree_skb(frame.skb);
	return ret;
}

static int xradio_upload_qosnull(struct xradio_vif *priv)
{
	int ret = 0;
	struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
	struct wsm_template_frame frame = {
		.frame_type = WSM_FRAME_TYPE_QOS_NULL,
		.rate = 0xFF,
	};
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	frame.skb = ieee80211_qosnullfunc_get(priv->hw, priv->vif);
	if (SYS_WARN(!frame.skb))
		return -ENOMEM;

	ret = wsm_set_template_frame(hw_priv, &frame, priv->if_id);
	dev_kfree_skb(frame.skb);
	return ret;
}

/* This API is nolonegr present in WSC */
#if 0
static int xradio_enable_beaconing(struct xradio_vif *priv, bool enable)
{
	struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
	struct wsm_beacon_transmit transmit = {
		.enableBeaconing = enable,
	};
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	return wsm_beacon_transmit(hw_priv, &transmit, priv->if_id);
}
#endif

static int xradio_start_ap(struct xradio_vif *priv)
{
	int ret;
#ifndef HIDDEN_SSID
	const u8 *ssidie;
	struct sk_buff *skb;
	int offset;
#endif
	struct ieee80211_bss_conf *conf = &priv->vif->bss_conf;
	struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);

	enum nl80211_channel_type chan_type = cfg80211_get_chandef_type(&conf->chandef);
#ifdef SUPPORT_HT40

	struct ieee80211_supported_band *sband;
	struct phy_mode_cfg PhyModeCfg;

	struct wsm_start start = {
		.mode = priv->vif->p2p ? WSM_START_MODE_P2P_GO :
					WSM_START_MODE_AP,
		/* TODO:COMBO:Change once mac80211 support is available */
		.channelNumber = hw_priv->channel->hw_value,
		.beaconInterval = conf->beacon_int,
		.DTIMPeriod = conf->dtim_period,
		.probeDelay = 100,
		.basicRateSet =
			xradio_rate_mask_to_wsm(hw_priv, conf->basic_rates),
#ifdef P2P_MULTIVIF
		.CTWindow = priv->vif->p2p ? 0xFFFFFFFF : 0,
#endif
	};

#else

	struct wsm_start start = {
		.mode = priv->vif->p2p ? WSM_START_MODE_P2P_GO : WSM_START_MODE_AP,
		/* TODO:COMBO:Change once mac80211 support is available */
		.band = (hw_priv->channel->band == NL80211_BAND_5GHZ) ?
				     WSM_PHY_BAND_5G : WSM_PHY_BAND_2_4G,
		.channelNumber = hw_priv->channel->hw_value,
		.beaconInterval = conf->beacon_int,
		.DTIMPeriod = conf->dtim_period,
		.preambleType = conf->use_short_preamble ?
				WSM_JOIN_PREAMBLE_SHORT : WSM_JOIN_PREAMBLE_LONG,
		.probeDelay = 100,
		.basicRateSet = xradio_rate_mask_to_wsm(hw_priv, conf->basic_rates),
#ifdef P2P_MULTIVIF
		.CTWindow = priv->vif->p2p ? 0xFFFFFFFF : 0,
#endif
	};

#endif

	struct wsm_operational_mode mode = {
		.power_mode = wsm_power_mode_quiescent,
		.disableMoreFlagUsage = true,
	};

#ifdef TES_P2P_000B_EXTEND_INACTIVITY_CNT
	/*
	 * TES_P2P_000B WorkAround:
	 * when inactivity count of a peer device is zero,
	 * which will reset while receiving a peer device frame,
	 * firmware will disconnect with it.
	 * due to some reason, such as scan/phy error, we miss these frame.
	 * then we can't keep connection with peer device.
	 * we set the min_inactivity value to large as WorkAround.
	 */
	struct wsm_inactivity inactivity = {
		.min_inactivity = 20,
		.max_inactivity = 10,
	};
#else
	struct wsm_inactivity inactivity = {
		.min_inactivity = 9,
		.max_inactivity = 1,
	};
#endif

	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

#ifdef SUPPORT_HT40

	sband = priv->hw->wiphy->bands[hw_priv->channel->band];

	PhyModeCfg.BandCfg = hw_priv->channel->band;
	if (PhyModeCfg.BandCfg == NL80211_BAND_5GHZ)
		PhyModeCfg.ModemFlags = (MODEM_F_A_OFDM |
					MODEM_F_N_OFDM);
	else
		PhyModeCfg.ModemFlags = (MODEM_F_B_DSSS |
					MODEM_F_A_OFDM |
					MODEM_F_N_OFDM);

	if (chan_type == NL80211_CHAN_HT40MINUS) {
		PhyModeCfg.ChWidthCfg = CHAN_WIDTH_40MHz;
		PhyModeCfg.PriChCfg   = PRIMARY_CH_1ST;
	} else if (chan_type == NL80211_CHAN_HT40PLUS) {
		PhyModeCfg.ChWidthCfg = CHAN_WIDTH_40MHz;
		PhyModeCfg.PriChCfg   = PRIMARY_CH_2ND;
	} else {
		PhyModeCfg.ChWidthCfg = CHAN_WIDTH_20MHz;
		PhyModeCfg.PriChCfg   = PRIMARY_CH_1ST;
	}

	if (chan_type == NL80211_CHAN_NO_HT) {
		PhyModeCfg.ModemFlags &= ~(MODEM_F_N_OFDM);
		PhyModeCfg.SGI_Enable = false;
		PhyModeCfg.GF_Enable = false;
	} else {
		PhyModeCfg.GF_Enable  =
			(sband->ht_cap.cap&IEEE80211_HT_CAP_GRN_FLD) ?
								true : false;
		PhyModeCfg.SGI_Enable =
			(sband->ht_cap.cap&
			(IEEE80211_HT_CAP_SGI_20|IEEE80211_HT_CAP_SGI_40)) ?
								true : false;
	}

	PhyModeCfg.STBC_Enable = false;
	PhyModeCfg.PreambleCfg = conf->use_short_preamble ?
		WSM_JOIN_PREAMBLE_SHORT : WSM_JOIN_PREAMBLE_LONG;

	start.PhyModeCfg = PhyModeCfg;

#endif

	if (priv->if_id)
		start.mode |= WSM_FLAG_MAC_INSTANCE_1;
	else
		start.mode &= ~WSM_FLAG_MAC_INSTANCE_1;

	hw_priv->connected_sta_cnt = 0;

#ifndef HIDDEN_SSID
	/* Get SSID */
	skb = ieee80211_beacon_get(priv->hw, priv->vif);
	if (SYS_WARN(!skb)) {
		ap_printk(XRADIO_DBG_ERROR, "%s, ieee80211_beacon_get failed\n",
			  __func__);
		return -ENOMEM;
	}

	offset = offsetof(struct ieee80211_mgmt, u.beacon.variable);
	ssidie = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
				  skb->len - offset);

	memset(priv->ssid, 0, sizeof(priv->ssid));
	if (ssidie) {
		priv->ssid_length = ssidie[1];
		if (SYS_WARN(priv->ssid_length > sizeof(priv->ssid)))
			priv->ssid_length = sizeof(priv->ssid);
		memcpy(priv->ssid, &ssidie[2], priv->ssid_length);
	} else {
		priv->ssid_length = 0;
	}
	dev_kfree_skb(skb);
#endif

	priv->beacon_int = conf->beacon_int;
	priv->join_dtim_period = conf->dtim_period;
	memset(&priv->last_tim[0], 0, sizeof(priv->last_tim));

	start.ssidLength = priv->ssid_length;
	memcpy(&start.ssid[0], priv->ssid, start.ssidLength);

	memset(&priv->link_id_db, 0, sizeof(priv->link_id_db));

#ifdef SUPPORT_HT40

	ap_printk(XRADIO_DBG_NIY, "[AP] ch: %d(%d), bcn: %d(%d), "\
				"bss_rate: 0x%.8X, ssid: %.*s.\n",
				start.channelNumber, start.PhyModeCfg.BandCfg,
				start.beaconInterval, start.DTIMPeriod,
				start.basicRateSet, start.ssidLength,
				start.ssid);
	ret = SYS_WARN(wsm_start(hw_priv, &start, priv->if_id));

	ap_printk(XRADIO_DBG_WARN, "[HT40][%s][PhyModeCfg:0x%04x]\n",
				__func__, *(u16 *)&start.PhyModeCfg);

#else

	ap_printk(XRADIO_DBG_NIY, "[AP] ch: %d(%d), bcn: %d(%d), " \
		  "bss_rate: 0x%.8X, ssid: %.*s.\n",
		  start.channelNumber,  start.band,
		  start.beaconInterval, start.DTIMPeriod,
		  start.basicRateSet, start.ssidLength, start.ssid);
	ret = SYS_WARN(wsm_start(hw_priv, &start, priv->if_id));

#endif
	if (!ret && priv->vif->p2p) {
		ap_printk(XRADIO_DBG_NIY,
			  "[AP] Setting p2p powersave configuration.\n");
		SYS_WARN(wsm_set_p2p_ps_modeinfo(hw_priv,
			&priv->p2p_ps_modeinfo, priv->if_id));
#if defined(CONFIG_XRADIO_USE_EXTENSIONS)
		xradio_notify_noa(priv, XRADIO_NOA_NOTIFICATION_DELAY);
#endif
	}

	/*Set Inactivity time */
	if (!(strstr(&start.ssid[0], "6.1.12"))) {
		wsm_set_inactivity(hw_priv, &inactivity, priv->if_id);
	}
	if (!ret) {
#ifndef AP_AGGREGATE_FW_FIX
		SYS_WARN(wsm_set_block_ack_policy(hw_priv,
			 XRADIO_TX_BLOCK_ACK_DISABLED_FOR_ALL_TID,
			 XRADIO_RX_BLOCK_ACK_DISABLED_FOR_ALL_TID, priv->if_id));
#else
		if ((priv->if_id == 1) && !hw_priv->is_go_thru_go_neg)
			SYS_WARN(wsm_set_block_ack_policy(hw_priv,
				 XRADIO_TX_BLOCK_ACK_ENABLED_FOR_ALL_TID,
				 XRADIO_RX_BLOCK_ACK_ENABLED_FOR_ALL_TID, priv->if_id));
		else
			SYS_WARN(wsm_set_block_ack_policy(hw_priv,
				 XRADIO_TX_BLOCK_ACK_ENABLED_FOR_ALL_TID,
				 XRADIO_RX_BLOCK_ACK_ENABLED_FOR_ALL_TID, priv->if_id));
#endif
		priv->join_status = XRADIO_JOIN_STATUS_AP;
		/* xradio_update_filtering(priv); */
	}
	SYS_WARN(wsm_set_operational_mode(hw_priv, &mode, priv->if_id));
	hw_priv->vif0_throttle = XRWL_HOST_VIF0_11N_THROTTLE;
	hw_priv->vif1_throttle = XRWL_HOST_VIF0_11N_THROTTLE;
	ap_printk(XRADIO_DBG_WARN, "vif%d, AP/GO mode THROTTLE=%d\n",
		  priv->if_id, priv->if_id == 0 ?
		  hw_priv->vif0_throttle : hw_priv->vif1_throttle);
	return ret;
}

static int xradio_update_beaconing(struct xradio_vif *priv)
{
	struct ieee80211_bss_conf *conf = &priv->vif->bss_conf;
	struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
	struct wsm_reset reset = {
		.link_id = 0,
		.reset_statistics = true,
	};
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	if (priv->mode == NL80211_IFTYPE_AP) {
		/* TODO: check if changed channel, band */
		if (priv->join_status != XRADIO_JOIN_STATUS_AP ||
		    priv->beacon_int != conf->beacon_int) {
			ap_printk(XRADIO_DBG_WARN, "ap restarting!\n");
			wsm_lock_tx(hw_priv);
			if (priv->join_status != XRADIO_JOIN_STATUS_PASSIVE)
				SYS_WARN(wsm_reset(hw_priv, &reset, priv->if_id));
			priv->join_status = XRADIO_JOIN_STATUS_PASSIVE;
			SYS_WARN(xradio_start_ap(priv));
			wsm_unlock_tx(hw_priv);
		} else
			ap_printk(XRADIO_DBG_NIY, "ap started join_status: %d\n",
				  priv->join_status);
	}
	return 0;
}

int xradio_find_link_id(struct xradio_vif *priv, const u8 *mac)
{
	int i, ret = 0;
	spin_lock_bh(&priv->ps_state_lock);
	for (i = 0; i < MAX_STA_IN_AP_MODE; ++i) {
		if (!memcmp(mac, priv->link_id_db[i].mac, ETH_ALEN) &&
		    priv->link_id_db[i].status) {
			priv->link_id_db[i].timestamp = jiffies;
			ret = i + 1;
			break;
		}
	}
	spin_unlock_bh(&priv->ps_state_lock);
	return ret;
}

int xradio_alloc_link_id(struct xradio_vif *priv, const u8 *mac)
{
	int i, ret = 0;
	unsigned long max_inactivity = 0;
	unsigned long now = jiffies;
	struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	spin_lock_bh(&priv->ps_state_lock);
	for (i = 0; i < MAX_STA_IN_AP_MODE; ++i) {
		if (!priv->link_id_db[i].status) {
			ret = i + 1;
			break;
		} else if (priv->link_id_db[i].status != XRADIO_LINK_HARD &&
			   !hw_priv->tx_queue_stats.link_map_cache[priv->if_id][i + 1]) {
			unsigned long inactivity = now - priv->link_id_db[i].timestamp;
			if (inactivity < max_inactivity)
				continue;
			max_inactivity = inactivity;
			ret = i + 1;
		}
	}
	if (ret) {
		struct xradio_link_entry *entry = &priv->link_id_db[ret - 1];
		ap_printk(XRADIO_DBG_NIY, "STA added, link_id: %d\n", ret);
		entry->status = XRADIO_LINK_RESERVE;
		memcpy(&entry->mac, mac, ETH_ALEN);
		memset(&entry->buffered, 0, XRADIO_MAX_TID);
		skb_queue_head_init(&entry->rx_queue);
		wsm_lock_tx_async(hw_priv);
		if (queue_work(hw_priv->workqueue, &priv->link_id_work) <= 0)
			wsm_unlock_tx(hw_priv);
	} else {
		ap_printk(XRADIO_DBG_WARN, "Early: no more link IDs available.\n");
	}

	spin_unlock_bh(&priv->ps_state_lock);
	return ret;
}

void xradio_link_id_work(struct work_struct *work)
{
	struct xradio_vif *priv =
	    container_of(work, struct xradio_vif, link_id_work);
	struct xradio_common *hw_priv = priv->hw_priv;

	wsm_flush_tx(hw_priv);
	xradio_link_id_gc_work(&priv->link_id_gc_work.work);
	wsm_unlock_tx(hw_priv);
}

void xradio_link_id_gc_work(struct work_struct *work)
{
	struct xradio_vif *priv =
	    container_of(work, struct xradio_vif, link_id_gc_work.work);
	struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
	struct wsm_map_link map_link = {
		.link_id = 0,
	};
	unsigned long now = jiffies;
	unsigned long next_gc = -1;
	long ttl;
	bool need_reset;
	u32 mask;
	int i;
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	if (priv->join_status != XRADIO_JOIN_STATUS_AP)
		return;

	wsm_lock_tx(hw_priv);
	spin_lock_bh(&priv->ps_state_lock);
	for (i = 0; i < MAX_STA_IN_AP_MODE; ++i) {
		need_reset = false;
		mask = BIT(i + 1);
		if (priv->link_id_db[i].status == XRADIO_LINK_RESERVE ||
		    (priv->link_id_db[i].status == XRADIO_LINK_HARD &&
		     !(priv->link_id_map & mask))) {
			if (priv->link_id_map & mask) {
				priv->sta_asleep_mask &= ~mask;
				priv->pspoll_mask &= ~mask;
				need_reset = true;
			}
			priv->link_id_map |= mask;
			if (priv->link_id_db[i].status != XRADIO_LINK_HARD)
				priv->link_id_db[i].status = XRADIO_LINK_SOFT;
			memcpy(map_link.mac_addr, priv->link_id_db[i].mac, ETH_ALEN);
			spin_unlock_bh(&priv->ps_state_lock);
			if (need_reset) {
				SYS_WARN(xrwl_unmap_link(priv, i + 1));
			}
			map_link.link_id = i + 1;
			SYS_WARN(wsm_map_link(hw_priv, &map_link, priv->if_id));
			next_gc = min(next_gc, XRADIO_LINK_ID_GC_TIMEOUT);
			spin_lock_bh(&priv->ps_state_lock);
		} else if (priv->link_id_db[i].status == XRADIO_LINK_SOFT) {
			ttl = priv->link_id_db[i].timestamp - now +
			      XRADIO_LINK_ID_GC_TIMEOUT;
			if (ttl <= 0) {
				need_reset = true;
				priv->link_id_db[i].status = XRADIO_LINK_OFF;
				priv->link_id_map &= ~mask;
				priv->sta_asleep_mask &= ~mask;
				priv->pspoll_mask &= ~mask;
				memset(map_link.mac_addr, 0, ETH_ALEN);
				spin_unlock_bh(&priv->ps_state_lock);
				SYS_WARN(xrwl_unmap_link(priv, i + 1));
				spin_lock_bh(&priv->ps_state_lock);
			} else {
				next_gc = min_t(unsigned long, next_gc, ttl);
			}
#if defined(CONFIG_XRADIO_USE_EXTENSIONS)
		} else if (priv->link_id_db[i].status == XRADIO_LINK_RESET ||
			   priv->link_id_db[i].status == XRADIO_LINK_RESET_REMAP) {
			int status = priv->link_id_db[i].status;
			priv->link_id_db[i].status = XRADIO_LINK_OFF;
			priv->link_id_db[i].timestamp = now;
			spin_unlock_bh(&priv->ps_state_lock);
			SYS_WARN(xrwl_unmap_link(priv, i + 1));
			if (status == XRADIO_LINK_RESET_REMAP) {
				memcpy(map_link.mac_addr, priv->link_id_db[i].mac, ETH_ALEN);
				map_link.link_id = i + 1;
				SYS_WARN(wsm_map_link(hw_priv, &map_link, priv->if_id));
				next_gc = min(next_gc, XRADIO_LINK_ID_GC_TIMEOUT);
				priv->link_id_db[i].status = priv->link_id_db[i].prev_status;
			}
			spin_lock_bh(&priv->ps_state_lock);
#endif
		}
		if (need_reset) {
			skb_queue_purge(&priv->link_id_db[i].rx_queue);
			ap_printk(XRADIO_DBG_NIY, "STA removed, link_id: %d\n", i + 1);
		}
	}
	spin_unlock_bh(&priv->ps_state_lock);
	if (next_gc != -1)
		queue_delayed_work(hw_priv->workqueue,
				   &priv->link_id_gc_work, next_gc);
	wsm_unlock_tx(hw_priv);
}

#if defined(CONFIG_XRADIO_USE_EXTENSIONS)
void xradio_notify_noa(struct xradio_vif *priv, int delay)
{
#if 0
	struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
	struct cfg80211_p2p_ps p2p_ps = { 0 };
	struct wsm_p2p_ps_modeinfo *modeinfo;
	modeinfo = &priv->p2p_ps_modeinfo;

	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	if (priv->join_status != XRADIO_JOIN_STATUS_AP)
		return;

	if (delay)
		msleep(delay);

	if (!SYS_WARN(wsm_get_p2p_ps_modeinfo(hw_priv, modeinfo))) {
#if defined(CONFIG_XRADIO_DEBUG)
		print_hex_dump_bytes("[AP] p2p_get_ps_modeinfo: ", DUMP_PREFIX_NONE,
				    (u8 *)modeinfo, sizeof(*modeinfo));
#endif /* CONFIG_XRADIO_DEBUG */
		p2p_ps.opp_ps = !!(modeinfo->oppPsCTWindow & BIT(7));
		p2p_ps.ctwindow = modeinfo->oppPsCTWindow & (~BIT(7));
		p2p_ps.count = modeinfo->count;
		p2p_ps.start = __le32_to_cpu(modeinfo->startTime);
		p2p_ps.duration = __le32_to_cpu(modeinfo->duration);
		p2p_ps.interval = __le32_to_cpu(modeinfo->interval);
		p2p_ps.index = modeinfo->reserved;

		/* ieee80211_p2p_noa_notify(priv->vif, &p2p_ps, GFP_KERNEL); */
	}
#endif
}
#endif

int xrwl_unmap_link(struct xradio_vif *priv, int link_id)
{
	struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
	int ret = 0;
	struct wsm_operational_mode mode = {
		.power_mode = wsm_power_mode_quiescent,
		.disableMoreFlagUsage = true,
	};
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	if (is_hardware_xradio(hw_priv)) {
		struct wsm_map_link maplink = {
			.link_id = link_id,
			.unmap = true,
		};
		if (link_id)
			memcpy(&maplink.mac_addr[0],
			       priv->link_id_db[link_id - 1].mac, ETH_ALEN);
		return wsm_map_link(hw_priv, &maplink, priv->if_id);
	} else {
		struct wsm_reset reset = {
			.link_id = link_id,
			.reset_statistics = true,
		};
		ret = wsm_reset(hw_priv, &reset, priv->if_id);
		SYS_WARN(wsm_set_operational_mode(hw_priv, &mode, priv->if_id));
		return ret;
	}
}

#ifdef AP_HT_CAP_UPDATE
void xradio_ht_info_update_work(struct work_struct *work)
{
	struct sk_buff *skb;
	struct ieee80211_mgmt *mgmt;
	u8 *ht_info, *ies;
	u32 ies_len;
	struct xradio_vif *priv =
	    container_of(work, struct xradio_vif, ht_info_update_work);
	struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
	struct wsm_update_ie update_ie = {
		.what = WSM_UPDATE_IE_BEACON,
		.count = 1,
	};
	ap_printk(XRADIO_DBG_TRC, "%s\n", __func__);

	skb = ieee80211_beacon_get(priv->hw, priv->vif);
	if (SYS_WARN(!skb))
		return;

	mgmt = (void *)skb->data;
	ies = mgmt->u.beacon.variable;
	ies_len = skb->len - (u32)(ies - (u8 *)mgmt);
	ht_info = (u8 *)cfg80211_find_ie(WLAN_EID_HT_INFORMATION, ies, ies_len);
	if (ht_info && priv->ht_info == HT_INFO_MASK) {
		ht_info[HT_INFO_OFFSET] |= 0x11;
		update_ie.ies = ht_info;
		update_ie.length = HT_INFO_IE_LEN + 2;
		SYS_WARN(wsm_update_ie(hw_priv, &update_ie, priv->if_id));
	}
	dev_kfree_skb(skb);
}
#endif
